import sdk from '../core';
import { config, configKey } from '../config';
import { ItemType } from '../shared/face/enums';
import { ComType } from '../core/tool/component';
import { 
    TaskType, 
    TaskStatus, 
    TaskTargetType, 
    TaskConfig, 
    TaskTarget, 
    TaskReward, 
    PlayerTaskProgress, 
    ServerTaskProgress,
    TaskSystemData,
    RankingData
} from '../core/rpg/types/task';
import TaskManage from '../core/manage/TaskManage';
import { ModernTaskService } from './ModernTaskService';
import { DIContainer } from '../infrastructure/di';
import { staticToInstance } from './base/LegacyServiceAdapter';

/**
 * 任务服务类 - 兼容性包装器
 * 职责：
 * 1. 为旧代码提供兼容性支持
 * 2. 将调用转发到ModernTaskService
 * 3. 静态方法到实例方法的转换
 * 4. 逐步迁移到新架构
 */
export class TaskService {
    // 保留静态实例用于兼容性
    private static modernTaskService: ModernTaskService;

    // 全服任务邮件发送状态跟踪（兼容性保留）
    private static serverTaskMailSent: Set<string> = new Set();

    /**
     * 初始化现代化服务
     */
    @staticToInstance(ModernTaskService)
    static initialize(container?: DIContainer): void {
        if (!this.modernTaskService) {
            this.modernTaskService = new ModernTaskService(container);
        }
    }

    /**
     * 获取现代化服务实例
     */
    @staticToInstance(ModernTaskService)
    static getModernService(): ModernTaskService {
        if (!this.modernTaskService) {
            this.initialize();
        }
        return this.modernTaskService;
    }

    /**
     * 获取任务配置 (兼容性方法)
     * @returns 任务配置列表
     * @deprecated 请使用 modernTaskService.getTaskConfigs 替代
     */
    @staticToInstance(ModernTaskService)
    static getTaskConfigs(): TaskConfig[] {
        try {
            const taskConfigs = config.get(configKey.配置_常规任务) as Map<string, any>;
            const configs: TaskConfig[] = [];
            taskConfigs.forEach((config: any, key: string) => {
                const targets = config.targets.map((target: any) => {
                    return {
                        type: target.type,
                        count: Number(target.count),
                        current: 0, // 重置为0，进度由玩家数据决定
                        description: target.description
                    }
                });
                const rewards = config.rewards.map((reward: any) => {
                    return {
                        type: reward.type,
                        id: reward.id,
                        count: Number(reward.count),
                        name: reward.name
                    }
                });
                configs.push({
                    id: key,
                    name: config.name,
                    description: config.description,
                    type: config.type,
                    targets: targets || [],
                    rewards: rewards || [],
                    startTime: 0,
                    endTime: 0,
                    duration: Number(config.duration)
                });
            });

            return configs;
        } catch (error) {
            console.log('任务配置加载失败:', error);
            return [];
        }
    }

    /**
     * 获取任务配置 (现代化方法)
     * @returns 任务配置列表
     */
    @staticToInstance(ModernTaskService)
    static async getTaskConfigsAsync(): Promise<TaskConfig[]> {
        try {
            return await this.getModernService().getTaskConfigs();
        } catch (error) {
            console.error('获取任务配置失败:', error);
            return [];
        }
    }

    /**
     * 获取玩家的世界任务配置 (兼容性方法)
     * @param player 玩家对象
     * @param mapName 地图名称
     * @returns 世界任务配置列表
     * @deprecated 请使用 modernTaskService.getPlayerWorldTasks 替代
     */
    @staticToInstance(ModernTaskService)
    static async getPlayerWorldTaskConfigs(player: any, mapName: string): Promise<TaskConfig[]> {
        try {
            const playerId = player.id;
            
            // 先检查是否已有该地图的世界任务
            const existingWorldTasks = sdk.worldTask.getWorldTasks(mapName);
            
            // 过滤出属于当前玩家的世界任务
            const playerWorldTasks = existingWorldTasks.filter(task => 
                task.id.includes(playerId)
            );
            
            // 检查现有任务是否符合新格式（一个任务1-2个目标）
            if (playerWorldTasks.length > 0) {
                const validWorldTask = playerWorldTasks.find(task => 
                    task.id.startsWith('world_task_') && task.targets.length >= 1
                );
                
                if (validWorldTask) {
                    // 如果找到符合新格式的任务，直接返回，不重新生成
                    return [validWorldTask];
                } else {
                    // 如果现有任务格式不正确，清理旧任务并重新生成
                    console.log('清理旧格式的世界任务，重新生成...');
                    await sdk.worldTask.clearPlayerWorldTasks(playerId);
                }
            }
            
            // 如果没有找到现有任务，生成新的世界任务
            const newWorldTasks = await sdk.worldTask.generateWorldTasks(mapName, playerId);
            return newWorldTasks;
        } catch (error) {
            console.error('获取玩家世界任务配置失败:', error);
            return [];
        }
    }

    /**
     * 获取玩家世界任务 (现代化方法)
     * @param playerId 玩家ID
     * @param mapName 地图名称
     * @returns 世界任务列表
     */
    @staticToInstance(ModernTaskService)
    static async getPlayerWorldTasksAsync(playerId: string, mapName: string): Promise<TaskConfig[]> {
        try {
            return await this.getModernService().getPlayerWorldTasks(playerId, mapName);
        } catch (error) {
            console.error('获取玩家世界任务失败:', error);
            return [];
        }
    }



    /**
     * 获取玩家的世界任务
     * @param player 玩家对象
     * @param mapName 地图名称
     * @returns 世界任务列表
     */
    @staticToInstance(ModernTaskService)
    static async getPlayerWorldTasks(player: any, mapName: string): Promise<TaskConfig[]> {
        try {
            const playerId = player.id;
            const worldTasks = await sdk.worldTask.generateWorldTasks(mapName, playerId);
            return worldTasks;
        } catch (error) {
            console.error('获取玩家世界任务失败:', error);
            return [];
        }
    }

    /**
     * 清理玩家的世界任务
     * @param player 玩家对象
     * @param mapName 地图名称
     */
    @staticToInstance(ModernTaskService)
    static async clearPlayerWorldTasks(player: any, mapName: string): Promise<void> {
        try {
            const playerId = player.id;
            
            // 清理WorldTaskManage中的数据
            await sdk.worldTask.clearPlayerWorldTasks(playerId);
            
            // 清理玩家任务组件中的世界任务数据
            const taskComponent = player.getComponent('task') as any;
            if (taskComponent && taskComponent.taskData && taskComponent.taskData.playerTasks) {
                // 移除所有世界任务
                taskComponent.taskData.playerTasks = taskComponent.taskData.playerTasks.filter((task: any) => {
                    // 检查是否是世界任务（通过taskId包含world_前缀或包含玩家ID来判断）
                    return !(task.taskId.includes('world_') || task.taskId.includes(playerId));
                });
                
                console.log(`已清理玩家 ${playerId} 任务组件中的世界任务`);
            }
        } catch (error) {
            console.error('清理玩家世界任务失败:', error);
        }
    }

    /**
     * 初始化玩家任务数据
     * @param player 玩家对象
     * @returns 任务系统数据
     */
    @staticToInstance(ModernTaskService)
    static initPlayerTaskData(player: any): TaskSystemData {
        const taskComponent = player.getComponent('task') as any;
        if (!taskComponent) {
            return {
                playerTasks: [],
                serverTasks: [],
                lastUpdateTime: Date.now()
            };
        }

        const taskData = taskComponent.taskData || {};
        return {
            playerTasks: taskData.playerTasks || [],
            serverTasks: taskData.serverTasks || [],
            lastUpdateTime: taskData.lastUpdateTime || Date.now()
        };
    }

    /**
     * 更新任务进度 (兼容性方法)
     * @param player 玩家对象
     * @param targetType 目标类型
     * @param targetId 目标ID（可选）
     * @param count 增加的数量
     * @returns 更新结果
     * @deprecated 请使用 modernTaskService.updateTaskProgress 替代
     */
    @staticToInstance(ModernTaskService)
    static async updateTaskProgress(
        player: any, 
        targetType: TaskTargetType, 
        targetId?: string, 
        count: number = 1
    ): Promise<{
        success: boolean;
        message: string;
        updatedTasks: PlayerTaskProgress[];
        completedTasks: PlayerTaskProgress[];
    }> {
        const taskComponent = player.getComponent('task') as any;
        if (!taskComponent) {
            return {
                success: false,
                message: '任务组件未找到',
                updatedTasks: [],
                completedTasks: []
            };
        }

        const taskData = this.initPlayerTaskData(player);
        const taskConfigs = this.getTaskConfigs();
        const updatedTasks: PlayerTaskProgress[] = [];
        const completedTasks: PlayerTaskProgress[] = [];

        // 检查是否有全服任务需要更新进度
        const serverTasksToUpdate: string[] = [];

        // 同步任务配置 - 确保新任务能够被创建
        const validTaskIds = new Set(taskConfigs.map(config => config.id));
        
        // 过滤掉已删除的任务配置
        if (taskComponent.taskData && taskComponent.taskData.playerTasks) {
            taskComponent.taskData.playerTasks = taskComponent.taskData.playerTasks.filter((task: any) => {
                // 保留世界任务（因为它们有特殊的ID格式）
                if (task.taskId.startsWith('world_task_')) {
                    return true;
                }
                // 只保留在配置中存在的任务
                return validTaskIds.has(task.taskId);
            });
        }

        // 获取世界任务配置
        const com_pos = player.getComponent(ComType.位置) as any;
        let worldTaskConfigs: TaskConfig[] = [];
        if (com_pos && com_pos.sceneName && com_pos.sceneName !== 'default' && com_pos.sceneName !== '主城') {
            try {
                // 检查taskData.playerTasks中是否已有世界任务
                const existingWorldTasks = taskData.playerTasks.filter(t => 
                    t.taskId.startsWith('world_task_') && t.taskId.includes(com_pos.sceneName)
                );
                
                if (existingWorldTasks.length > 0) {
                    // 如果已有世界任务，直接使用现有的，不重新生成
                    worldTaskConfigs = existingWorldTasks.map(task => ({
                        id: task.taskId,
                        name: task.name || '',
                        description: task.description || '',
                        type: TaskType.世界任务,
                        targets: task.targets,
                        rewards: task.rewards || []
                    }));
                    
                    // 确保世界任务的奖励信息被正确保存到taskData中
                    for (const worldTask of existingWorldTasks) {
                        const existingTask = taskData.playerTasks.find(t => t.taskId === worldTask.taskId);
                        if (existingTask && worldTask.rewards) {
                            existingTask.rewards = worldTask.rewards;
                        }
                    }
                } else {
                    // 只有在没有世界任务时才生成新的
                    worldTaskConfigs = await this.getPlayerWorldTaskConfigs(player, com_pos.sceneName);
                }
            } catch (error) {
                console.error('获取世界任务配置失败:', error);
            }
        }

        // 合并所有任务配置
        const allTaskConfigs = [...taskConfigs, ...worldTaskConfigs];

        // 更新每个任务的进度
        for (const taskConfig of allTaskConfigs) {
            const existingTask = taskData.playerTasks.find(t => t.taskId === taskConfig.id);
            
            // 检查任务是否应该开始
            if (!existingTask && this.shouldStartTask(taskConfig)) {
                const newTask: PlayerTaskProgress = {
                    taskId: taskConfig.id,
                    status: TaskStatus.进行中,
                    targets: JSON.parse(JSON.stringify(taskConfig.targets)), // 深拷贝
                    startTime: Date.now(),
                    expired: false
                };
                
                // 如果是世界任务，保存完整的任务信息
                if (taskConfig.type === TaskType.世界任务) {
                    newTask.name = taskConfig.name;
                    newTask.description = taskConfig.description;
                    newTask.rewards = taskConfig.rewards;
                }
                
                taskData.playerTasks.push(newTask);
                console.log(`创建新任务: ${taskConfig.name} (ID: ${taskConfig.id})`);
            }

            const currentTask = taskData.playerTasks.find(t => t.taskId === taskConfig.id);
            if (!currentTask || currentTask.status !== TaskStatus.进行中) {
                continue;
            }

            // 更新目标进度
            let progressUpdated = false;
            
            // 全服任务使用共享进度
            if (taskConfig.type === TaskType.全服任务) {
                // 检查是否需要更新全服进度
                for (const target of currentTask.targets) {
                    if (target.type === targetType && (!targetId || target.targetId === targetId)) {
                        // 记录需要更新的全服任务
                        if (!serverTasksToUpdate.includes(taskConfig.id)) {
                            serverTasksToUpdate.push(taskConfig.id);
                        }
                        // 获取全服任务进度
                        const serverProgress = await this.getServerTaskProgress(taskConfig.id);
                        if (serverProgress) {
                            // 使用全服进度，但不超过目标值
                            target.current = Math.min(serverProgress.totalProgress, target.count);
                            progressUpdated = true;
                        }
                    }
                }
            } else {
                // 个人任务使用个人进度
                for (const target of currentTask.targets) {
                    if (target.type === targetType && (!targetId || target.targetId === targetId)) {
                        target.current = Math.min(target.current + count, target.count);
                        progressUpdated = true;
                    }
                }
            }

            if (progressUpdated) {
                // 检查任务是否完成
                const isCompleted = currentTask.targets.every(target => target.current >= target.count);
                if (isCompleted) {
                    // 对于世界任务，设置为已完成状态但不自动发放奖励
                    if (taskConfig.type === TaskType.世界任务) {
                        currentTask.status = TaskStatus.已完成;
                        currentTask.completeTime = Date.now();
                        completedTasks.push(currentTask);
                    } else {
                        // 其他任务类型保持原有逻辑
                        currentTask.status = TaskStatus.已领取;
                        currentTask.completeTime = Date.now();
                        completedTasks.push(currentTask);
                        
                        // 自动发放奖励
                        await this.autoClaimTaskReward(player, taskConfig.id);
                    }
                }

                updatedTasks.push(currentTask);
            }
        }

        // 自动更新全服任务进度
        for (const taskId of serverTasksToUpdate) {
            await this.updateServerTaskProgress(taskId, count);
        }

        // 保存更新后的任务数据
        if (taskComponent.taskData) {
            taskComponent.taskData.playerTasks = taskData.playerTasks;
            taskComponent.taskData.lastUpdateTime = Date.now();
        }

        return {
            success: true,
            message: `更新了${updatedTasks.length}个任务进度`,
            updatedTasks,
            completedTasks
        };
    }

    /**
     * 检查任务是否应该开始
     * @param taskConfig 任务配置
     * @returns 是否应该开始
     */
    @staticToInstance(ModernTaskService)
    private static shouldStartTask(taskConfig: TaskConfig): boolean {
        const now = Date.now();

        switch (taskConfig.type) {
            case TaskType.每日任务:
                // 每日任务每天凌晨4点重置
                return true; // 总是允许开始，重置逻辑在getPlayerTasks中处理
            case TaskType.每周任务:
                // 每周任务每周末凌晨重置
                const weekStart = this.getWeekStart();
                return now >= weekStart;
            case TaskType.每月任务:
                // 每月任务每月1号凌晨重置
                const monthStart = this.getMonthStart();
                return now >= monthStart;
            case TaskType.全服任务:
                // 全服任务跟随每日/每周/每月规则
                return true;
            case TaskType.限时任务:
                // 限时任务检查时间范围
                if (taskConfig.startTime && taskConfig.endTime) {
                    return now >= taskConfig.startTime && now <= taskConfig.endTime;
                }
                return true;
            case TaskType.世界任务:
                // 世界任务总是可以开始
                return true;
            default:
                return true;
        }
    }

    /**
     * 检查任务是否应该重置
     * @param task 任务进度
     * @param taskConfig 任务配置
     * @returns 是否应该重置
     */
    @staticToInstance(ModernTaskService)
    private static shouldResetTask(task: PlayerTaskProgress, taskConfig: TaskConfig): boolean {
        const now = Date.now();

        switch (taskConfig.type) {
            case TaskType.每日任务:
                // 每日任务每天凌晨4点重置
                const today4am = this.getToday4am();
                return task.startTime < today4am;
            case TaskType.每周任务:
                // 每周任务每周末凌晨重置
                const weekStart = this.getWeekStart();
                return task.startTime < weekStart;
            case TaskType.每月任务:
                // 每月任务每月1号凌晨重置
                const monthStart = this.getMonthStart();
                return task.startTime < monthStart;
            case TaskType.限时任务:
                // 限时任务时间到了就重置
                if (taskConfig.duration) {
                    const endTime = task.startTime + (taskConfig.duration * 60 * 1000);
                    return now > endTime;
                }
                return false;
            case TaskType.全服任务:
                // 全服任务暂时不重置
                return false;
            case TaskType.世界任务:
                // 世界任务不重置，离开地图时清理
                return false;
            default:
                return false;
        }
    }

    /**
     * 获取今天凌晨4点的时间戳
     * @returns 今天凌晨4点的时间戳
     */
    @staticToInstance(ModernTaskService)
    private static getToday4am(): number {
        const now = new Date();
        const today4am = new Date(now);
        today4am.setHours(4, 0, 0, 0);
        return today4am.getTime();
    }

    /**
     * 获取本周开始时间（周日凌晨4点）
     * @returns 本周开始时间戳
     */
    @staticToInstance(ModernTaskService)
    private static getWeekStart(): number {
        const now = new Date();
        const dayOfWeek = now.getDay(); // 0是周日
        const weekStart = new Date(now);
        weekStart.setDate(now.getDate() - dayOfWeek);
        weekStart.setHours(4, 0, 0, 0); // 凌晨4点
        return weekStart.getTime();
    }

    /**
     * 获取本月开始时间（每月1号凌晨4点）
     * @returns 本月开始时间戳
     */
    @staticToInstance(ModernTaskService)
    private static getMonthStart(): number {
        const now = new Date();
        const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
        monthStart.setHours(4, 0, 0, 0); // 凌晨4点
        return monthStart.getTime();
    }

    /**
     * 自动发放任务奖励（任务完成时自动调用）
     * @param player 玩家对象
     * @param taskId 任务ID
     * @returns 发放结果
     */
    @staticToInstance(ModernTaskService)
    private static async autoClaimTaskReward(player: any, taskId: string): Promise<{
        success: boolean;
        message: string;
        rewards?: TaskReward[];
    }> {
        const taskConfig = this.getTaskConfigs().find(t => t.id === taskId);
        if (!taskConfig) {
            return {
                success: false,
                message: '任务配置未找到'
            };
        }

        // 全服任务通过系统邮件发放奖励
        if (taskConfig.type === TaskType.全服任务) {
            return await this.sendServerTaskRewardMail(player, taskConfig);
        }

        // 个人任务直接发放到背包
        const bagComponent = player.getComponent('bag') as any;
        if (bagComponent && taskConfig.rewards.length > 0) {
            const rewards: TaskReward[] = [];
            
            taskConfig.rewards.forEach(reward => {
                try {
                    const prop = sdk.prop.createProp({
                        type: reward.type,
                        id: reward.id,
                        count: reward.count
                    });
                    bagComponent.addItem(prop);
                    rewards.push(reward);
                } catch (error) {
                    console.log(`自动奖励发放失败: ${reward.name} x${reward.count}`, error);
                }
            });

            return {
                success: true,
                message: `自动发放了${rewards.length}个奖励`,
                rewards
            };
        }

        return {
            success: false,
            message: '背包组件未找到或没有奖励'
        };
    }

    /**
     * 发送全服任务奖励邮件
     * @param player 玩家对象
     * @param taskConfig 任务配置
     * @returns 发送结果
     */
    @staticToInstance(ModernTaskService)
    private static async sendServerTaskRewardMail(player: any, taskConfig: TaskConfig): Promise<{
        success: boolean;
        message: string;
        rewards?: TaskReward[];
    }> {
        try {
            // 创建奖励道具
            const rewardItems: any[] = [];
            taskConfig.rewards.forEach(reward => {
                try {
                    const prop = sdk.prop.createProp({
                        type: reward.type,
                        id: reward.id,
                        count: reward.count
                    });
                    rewardItems.push(prop);
                } catch (error) {
                    console.log(`创建奖励道具失败: ${reward.name} x${reward.count}`, error);
                }
            });

            // 发送系统邮件
            try {
                await sdk.mail.send(
                    'sys', // 发送者ID
                    player.id, // 接收者ID
                    7, // 过期天数
                    `🎉全服任务奖励 - ${taskConfig.name}`, // 邮件标题
                    `恭喜您完成了全服任务"${taskConfig.name}"！\n\n这是您的奖励，请查收。`, // 邮件内容
                    rewardItems // 奖励道具
                );

                return {
                    success: true,
                    message: `全服任务奖励已通过邮件发放`,
                    rewards: taskConfig.rewards
                };
            } catch (error) {
                console.log('邮件发送失败:', error);
                return {
                    success: false,
                    message: '邮件发送失败'
                };
            }
        } catch (error) {
            console.log('发送全服任务奖励邮件失败:', error);
            return {
                success: false,
                message: '邮件发送失败'
            };
        }
    }

    /**
     * 领取任务奖励
     * @param player 玩家对象
     * @param taskId 任务ID
     * @returns 领取结果
     */
    @staticToInstance(ModernTaskService)
    static claimTaskReward(player: any, taskId: string): {
        success: boolean;
        message: string;
        rewards?: TaskReward[];
    } {
        const taskComponent = player.getComponent('task') as any;
        if (!taskComponent) {
            return {
                success: false,
                message: '任务组件未找到'
            };
        }

        const taskData = this.initPlayerTaskData(player);
        const task = taskData.playerTasks.find(t => t.taskId === taskId);
        
        if (!task) {
            return {
                success: false,
                message: '任务不存在'
            };
        }

        if (task.status !== TaskStatus.已完成) {
            return {
                success: false,
                message: '任务尚未完成'
            };
        }

        const taskConfig = this.getTaskConfigs().find(t => t.id === taskId);
        if (!taskConfig) {
            return {
                success: false,
                message: '任务配置不存在'
            };
        }

        // 发放奖励
        const bagComponent = player.getComponent('bag') as any;
        if (bagComponent && taskConfig.rewards.length > 0) {
            taskConfig.rewards.forEach(reward => {
                try {
                    const prop = sdk.prop.createProp({
                        type: reward.type,
                        id: reward.id,
                        count: reward.count
                    });
                    bagComponent.addItem(prop);
                } catch (error) {
                    console.log(`奖励发放失败: ${reward.name} x${reward.count}`, error);
                }
            });
        }

        // 更新任务状态
        task.status = TaskStatus.已领取;
        task.claimTime = Date.now();

        // 保存数据
        taskComponent.taskData = {
            ...taskData,
            lastUpdateTime: Date.now()
        };

        return {
            success: true,
            message: '奖励领取成功',
            rewards: taskConfig.rewards
        };
    }

    /**
     * 结算世界任务奖励
     * @param player 玩家对象
     * @returns 结算结果
     */
    @staticToInstance(ModernTaskService)
    static async settleWorldTasks(player: any): Promise<{
        success: boolean;
        message: string;
        rewards?: TaskReward[];
        completedTasks?: PlayerTaskProgress[];
    }> {
        const taskComponent = player.getComponent('task') as any;
        if (!taskComponent) {
            return {
                success: false,
                message: '任务组件未找到'
            };
        }

        // 直接从任务组件获取最新的任务数据
        const taskData = taskComponent.taskData || {};
        const playerTasks = taskData.playerTasks || [];
        const worldTasks = playerTasks.filter((t: any) => 
            t.taskId.startsWith('world_task_') && t.status === TaskStatus.已完成
        );

        if (worldTasks.length === 0) {
            return {
                success: false,
                message: '没有已完成的世界任务需要结算'
            };
        }

        const allRewards: TaskReward[] = [];
        const completedTasks: PlayerTaskProgress[] = [];

        // 处理每个已完成的世界任务
        for (const task of worldTasks) {
            // 使用任务自身的奖励信息（世界任务是动态生成的）
            if (task.rewards && task.rewards.length > 0) {
                const bagComponent = player.getComponent('bag') as any;
                if (bagComponent) {
                    task.rewards.forEach((reward: any) => {
                        try {
                            const prop = sdk.prop.createProp({
                                type: reward.type,
                                id: reward.id,
                                count: reward.count
                            });
                            bagComponent.addItem(prop);
                            allRewards.push(reward);
                        } catch (error) {
                            console.log(`世界任务奖励发放失败: ${reward.name} x${reward.count}`, error);
                        }
                    });
                }
            }

            // 更新任务状态为已领取
            task.status = TaskStatus.已领取;
            task.claimTime = Date.now();
            completedTasks.push(task);
        }

        // 保存数据 - 直接更新任务组件中的数据
        if (taskComponent.taskData) {
            taskComponent.taskData.playerTasks = playerTasks;
            taskComponent.taskData.lastUpdateTime = Date.now();
        }

        // 传送玩家回主城
        const posComponent = player.getComponent(ComType.位置) as any;
        if (posComponent) {
            posComponent.sceneName = 'default';
            posComponent.x = 0;
            posComponent.y = 0;
        }

        return {
            success: true,
            message: `成功结算了${completedTasks.length}个世界任务，已传送回主城`,
            rewards: allRewards,
            completedTasks
        };
    }

    /**
     * 获取玩家任务列表
     * @param player 玩家对象
     * @returns 任务列表
     */
    @staticToInstance(ModernTaskService)
    static async getPlayerTasks(player: any): Promise<{
        daily: PlayerTaskProgress[];
        weekly: PlayerTaskProgress[];
        monthly: PlayerTaskProgress[];
        server: PlayerTaskProgress[];
        limited: PlayerTaskProgress[];
        world: PlayerTaskProgress[];
    }> {
        const taskData = this.initPlayerTaskData(player);
        const taskConfigs = this.getTaskConfigs();

        const result = {
            daily: [] as PlayerTaskProgress[],
            weekly: [] as PlayerTaskProgress[],
            monthly: [] as PlayerTaskProgress[],
            server: [] as PlayerTaskProgress[],
            limited: [] as PlayerTaskProgress[],
            world: [] as PlayerTaskProgress[]
        };

        // 同步任务配置 - 移除已删除的任务，添加新任务
        const validTaskIds = new Set(taskConfigs.map(config => config.id));
        const taskComponent = player.getComponent('task') as any;
        
        if (taskComponent && taskComponent.taskData && taskComponent.taskData.playerTasks) {
            // 过滤掉已删除的任务配置
            taskComponent.taskData.playerTasks = taskComponent.taskData.playerTasks.filter((task: any) => {
                // 保留世界任务（因为它们有特殊的ID格式）
                if (task.taskId.startsWith('world_task_')) {
                    return true;
                }
                // 只保留在配置中存在的任务
                return validTaskIds.has(task.taskId);
            });
            
            console.log(`任务配置同步完成，保留 ${taskComponent.taskData.playerTasks.length} 个任务`);
        }

        // 处理世界任务 - 只在非主城的地图中生成
        const com_pos = player.getComponent(ComType.位置) as any;
        if (com_pos && com_pos.sceneName && com_pos.sceneName !== 'default' && com_pos.sceneName !== '主城') {
            try {
                // 先检查taskData.playerTasks中是否已有世界任务
                const existingWorldTasks = taskData.playerTasks.filter(t => 
                    t.taskId.startsWith('world_task_') && t.taskId.includes(com_pos.sceneName)
                );
                
                if (existingWorldTasks.length > 0) {
                    // 如果已有世界任务，直接使用现有的，避免重新生成
                    result.world = existingWorldTasks;
                    
                    // 确保世界任务的奖励信息被正确保存
                    for (const worldTask of existingWorldTasks) {
                        const existingTask = taskData.playerTasks.find(t => t.taskId === worldTask.taskId);
                        if (existingTask && worldTask.rewards) {
                            existingTask.rewards = worldTask.rewards;
                        }
                    }
                } else {
                    // 如果没有世界任务，生成新的
                    const worldTaskConfigs = await this.getPlayerWorldTaskConfigs(player, com_pos.sceneName);
                    
                    for (const worldTaskConfig of worldTaskConfigs) {
                        // 创建新的世界任务，包含完整信息
                        const newWorldTask: PlayerTaskProgress = {
                            taskId: worldTaskConfig.id,
                            name: worldTaskConfig.name,
                            description: worldTaskConfig.description,
                            status: TaskStatus.进行中,
                            targets: JSON.parse(JSON.stringify(worldTaskConfig.targets)),
                            rewards: worldTaskConfig.rewards,
                            startTime: Date.now(),
                            expired: false
                        };
                        
                        // 保存到玩家任务数据中
                        taskData.playerTasks.push(newWorldTask);
                        result.world.push(newWorldTask);
                    }
                }
            } catch (error) {
                console.error('处理世界任务失败:', error);
            }
        }

        for (const taskConfig of taskConfigs) {
            const existingTask = taskData.playerTasks.find(t => t.taskId === taskConfig.id);
            
            if (existingTask) {
                // 检查任务是否应该重置
                if (this.shouldResetTask(existingTask, taskConfig)) {
                    // 重置任务进度
                    existingTask.status = TaskStatus.进行中;
                    existingTask.startTime = Date.now();
                    existingTask.completeTime = undefined; // 重置完成时间
                    existingTask.targets.forEach(target => {
                        target.current = 0;
                    });
                    console.log(`任务 ${taskConfig.name} 已重置`);
                }

                switch (taskConfig.type) {
                    case TaskType.每日任务:
                        result.daily.push(existingTask);
                        break;
                    case TaskType.每周任务:
                        result.weekly.push(existingTask);
                        break;
                    case TaskType.每月任务:
                        result.monthly.push(existingTask);
                        break;
                    case TaskType.全服任务:
                        result.server.push(existingTask);
                        break;
                    case TaskType.限时任务:
                        result.limited.push(existingTask);
                        break;
                }
            } else if (this.shouldStartTask(taskConfig)) {
                console.log(`创建新任务: ${taskConfig.name} (ID: ${taskConfig.id})`);
                
                // 创建新任务
                const newTask: PlayerTaskProgress = {
                    taskId: taskConfig.id,
                    name: taskConfig.name, // 保存任务名称
                    description: taskConfig.description, // 保存任务描述
                    status: TaskStatus.进行中,
                    targets: JSON.parse(JSON.stringify(taskConfig.targets)).map((target: any) => ({
                        ...target,
                        current: 0 // 确保新任务的进度从0开始
                    })),
                    rewards: taskConfig.rewards, // 保存任务奖励
                    startTime: Date.now(),
                    expired: false
                };

                // 保存新任务到玩家数据中
                taskData.playerTasks.push(newTask);

                switch (taskConfig.type) {
                    case TaskType.每日任务:
                        result.daily.push(newTask);
                        break;
                    case TaskType.每周任务:
                        result.weekly.push(newTask);
                        break;
                    case TaskType.每月任务:
                        result.monthly.push(newTask);
                        break;
                    case TaskType.全服任务:
                        result.server.push(newTask);
                        break;
                    case TaskType.限时任务:
                        result.limited.push(newTask);
                        break;
                }
            }
        }

        // 保存更新后的任务数据
        if (taskComponent && taskComponent.taskData) {
            taskComponent.taskData.playerTasks = taskData.playerTasks;
            taskComponent.taskData.lastUpdateTime = Date.now();
        }

        return result;
    }

    /**
     * 检查全服任务完成状态并发放奖励
     * @param player 玩家对象
     * @param taskId 任务ID
     * @returns 检查结果
     */
    @staticToInstance(ModernTaskService)
    static async checkServerTaskCompletion(player: any, taskId: string): Promise<{
        success: boolean;
        message: string;
        completed: boolean;
        rewards?: TaskReward[];
    }> {
        const taskConfig = this.getTaskConfigs().find(t => t.id === taskId);
        if (!taskConfig || taskConfig.type !== TaskType.全服任务) {
            return {
                success: false,
                message: '不是全服任务',
                completed: false
            };
        }

        const taskComponent = player.getComponent('task') as any;
        if (!taskComponent) {
            return {
                success: false,
                message: '任务组件未找到',
                completed: false
            };
        }

        const taskData = this.initPlayerTaskData(player);
        const currentTask = taskData.playerTasks.find(t => t.taskId === taskId);
        
        if (!currentTask || currentTask.status !== TaskStatus.进行中) {
            return {
                success: false,
                message: '任务不存在或已完成',
                completed: false
            };
        }

        // 获取全服进度
        const serverProgress = await this.getServerTaskProgress(taskId);
        if (!serverProgress) {
            return {
                success: false,
                message: '全服进度数据不存在',
                completed: false
            };
        }

        // 检查是否完成
        const isCompleted = currentTask.targets.every(target => 
            Math.min(serverProgress.totalProgress, target.count) >= target.count
        );

        if (isCompleted && currentTask.status === TaskStatus.进行中) {
            // 更新任务状态
            currentTask.status = TaskStatus.已领取;
            currentTask.completeTime = Date.now();

            // 保存更新后的数据
            taskComponent.taskData = {
                ...taskData,
                lastUpdateTime: Date.now()
            };

            // 发放奖励
            const rewardResult = await this.autoClaimTaskReward(player, taskId);

            return {
                success: true,
                message: '全服任务已完成，奖励已发放',
                completed: true,
                rewards: rewardResult.rewards
            };
        }

        return {
            success: true,
            message: '全服任务进行中',
            completed: false
        };
    }

    /**
     * 获取全服任务进度
     * @param taskId 任务ID
     * @returns 全服任务进度
     */
    @staticToInstance(ModernTaskService)
    static getServerTaskProgress(taskId: string): ServerTaskProgress | null {
        return TaskManage.getServerTaskProgress(taskId);
    }

    /**
     * 更新全服任务进度
     * @param taskId 任务ID
     * @param progress 增量
     * @returns 更新结果
     */
    @staticToInstance(ModernTaskService)
    static updateServerTaskProgress(taskId: string, progress: number = 1): {
        success: boolean;
        message: string;
        serverProgress?: ServerTaskProgress;
    } {
        return TaskManage.updateServerTaskProgress(taskId, progress);
    }

    /**
     * 重置全服任务
     * @returns 重置结果
     */
    @staticToInstance(ModernTaskService)
    static resetServerTasks(): {
        success: boolean;
        message: string;
        resetCount: number;
    } {
        try {
            let resetCount = 0;
            
            // 清空全服任务进度
            TaskManage.resetServerTaskProgress();
            
            // 清空全服任务邮件发送状态
            this.serverTaskMailSent.clear();
            
            // 获取所有在线玩家
            const onlinePlayers = sdk.user.getPlayers();
            
            // 重置所有玩家的全服任务
            for (const player of onlinePlayers) {
                const taskComponent = player.getComponent(ComType.任务) as any;
                if (taskComponent && taskComponent.taskData) {
                    const taskData = taskComponent.taskData;
                    
                    // 重置全服任务
                    if (taskData.playerTasks) {
                        for (const task of taskData.playerTasks) {
                            const taskConfig = this.getTaskConfigs().find(t => t.id === task.taskId);
                            if (taskConfig && taskConfig.type === TaskType.全服任务) {
                                // 重置任务状态
                                task.status = TaskStatus.进行中;
                                task.startTime = Date.now();
                                task.completeTime = undefined;
                                task.claimTime = undefined;
                                
                                // 重置目标进度
                                task.targets.forEach((target: any) => {
                                    target.current = 0;
                                });
                                
                                resetCount++;
                            }
                        }
                        
                        // 保存更新后的数据
                        taskComponent.taskData = {
                            ...taskData,
                            lastUpdateTime: Date.now()
                        };
                    }
                }
            }
            
            console.log(`全服任务重置完成，重置了 ${resetCount} 个任务`);
            
            return {
                success: true,
                message: `全服任务重置成功，重置了 ${resetCount} 个任务`,
                resetCount
            };
        } catch (error) {
            console.error('重置全服任务失败:', error);
            return {
                success: false,
                message: '重置全服任务失败',
                resetCount: 0
            };
        }
    }


} 